\documentclass[a4paper,11pt]{article}

\usepackage{lscape}
\usepackage{geometry}
\usepackage[utf8]{inputenc}
\usepackage[francais]{babel}
\usepackage[T1]{fontenc}
\usepackage{gantt}
\usepackage{tikz}
\usepackage{tikz-uml}
\usepackage{relsize}
\usepackage{color}
\definecolor{dkgreen}{rgb}{0,0.6,0}
\definecolor{gray}{rgb}{0.5,0.5,0.5}
\definecolor{mauve}{rgb}{0.58,0,0.82}

\usepackage{listings}
\usepackage{float}
\usepackage{kpfonts}

\usepackage{graphicx}
%\usepackage{rotating}

\lstset{
  language=C++,
  basicstyle=\footnotesize,
  backgroundcolor=\color{white},
  keywordstyle=\color{red},
  commentstyle=\color{dkgreen},
  stringstyle=\color{mauve},
  numberstyle=\color{red},
  morekeywords={string},
  frame=BL,
  aboveskip=1em,
  belowskip=2em,
}
\lstset{
  literate={ù}{{\`u}}1
  {é}{{\'e}}1
  {è}{{\'e}}1
  {à}{{\`a}}1
}


\lstdefinelanguage{tikzuml}{language=[LaTeX]TeX, classoffset=0, morekeywords={umlbasiccomponent, umlprovidedinterface, umlrequiredinterface, umldelegateconnector, umlassemblyconnector, umlVHVassemblyconnector, umlHVHassemblyconnector, umlnote, umlusecase, umlactor, umlinherit, umlassoc, umlVHextend, umlinclude, umlstateinitial, umlbasicstate, umltrans, umlstatefinal, umlVHtrans, umlHVtrans, umldatabase, umlmulti, umlobject, umlfpart, umlcreatecall, umlclass, umlvirt, umlunicompo, umlimport, umlaggreg}, classoffset=1, morekeywords={umlcomponent, umlsystem, umlstate, umlseqdiag, umlcall, umlcallself, umlfragment, umlpackage}, classoffset=0,  sensitive=true, morecomment=[l]{\%}}

\geometry{margin=2.5cm}
\geometry{headheight=15pt}

\usepackage{fancyhdr}
\usepackage{fancyvrb}
\usepackage{float}
\usepackage[footnote,smaller]{acronym}

\pagestyle{fancy}
\rhead{RE203 - Projet de Réseau}

% \acrodef{LABRI}{Laboratoire Bordelais de Recherche en Informatique}

\begin{document}

\begin{titlepage}
  \begin{center}

    \textsc{\LARGE RE203 - Projet de Réseau}\\[2cm]
    \textsc{\large Rapport Intermédiaire}\\[3cm]
    Maxime \textsc{Bellier} \ \ \ Jean-Michaël \textsc{Celerier}\\
    Julien \textsc{Chaumont} \ \ \ Bazire \textsc{Houssin} \ \ \ Sylvain \textsc{Vaglica}\\[1cm]
    \textsc{Groupe 3}\\[1.5cm]
    \textsc{\large 23/04/2013 }\\[1.5cm]
    \includegraphics[width=8cm]{logo.png}

  \end{center}
  \vspace{3cm}

\end{titlepage}

\clearpage

\section*{Introduction}

L'objectif du projet est de réaliser un programme capable de simuler un réseau. Il se base sur deux composantes principales: les routeurs et le contrôleur. Le résultat final devra se présenter sous la forme de deux programmes distincts, car ceux-ci ne communiqueront que par le réseau, de sorte que leur code source ne doit pas influencer. Pour ce faire, il a été imposé de développer en utilisant deux langages distincts, le langage C, ainsi qu'un langage orienté objet. D'un commun accord au sein du groupe, c'est le langage C++ qui a été choisi pour coder les routeurs, tandis que le C servira à la réalisation du contrôleur.

Contrôleur et routeurs, ainsi que l'état d'avancement de leur implémentation, seront détaillés dans la suite de ce premier rapport.

\section{Le contrôleur}

\subsection{Son rôle}

Le contrôleur, comme son nom l'indique, a pour mission du superviser l'intégralité du réseau. C'est à lui de l'initialiser, à partir d'une topologie donnée par l'utilisateur, et de maintenir la communication avec les routeurs pour mettre à jour ses informations et les transmettre.

Il faut cependant noter que son rôle est purement théorique, puisque dans la plupart des réseaux réels, ce sont aux routeurs de communiquer entre eux pour mettre à jour leurs connaissances sur le réseau. Dans le cadre du projet, cette mise à jour des connaissances des routeurs se fait justement auprès du contrôleur qui, lui, doit avoir la connaissance de la totalité du réseau. Pour ce faire, les routeurs se connectant ou se déconnectant du réseau doivent se signaler auprès du contrôleur avant d'effectuer l'action.

\subsection{Structure}

Plusieurs modules distincts composent le contrôleur, chacun ayant ses propres besoins en matière de structures de données:
\begin{itemize}
\item une invite de commande pour communiquer avec l'utilisateur et afficher les résultats des différentes requêtes entre lui et les routeurs;
\item la gestion du réseau sous forme d'un graphe initialisé à partir d'un fichier au format \textit{dot}\footnote{http://www.graphviz.org/content/dot-language};
\item un moyen de communiquer via le réseau avec les routeurs.
\end{itemize}

La communication sur le réseau se fait à l'aide de la bibliothèque C \texttt{sys/socket.h}, complète et largement utilisée. La gestion des graphes, quant à elle, utilise la bibliothèque C \texttt{graphviz/graph.h} fournie avec l'ensemble d'outils \textit{Graphviz}. Le principal avantage est qu'elle permet très facilement le passage d'un fichier au format \textit{it} à une structure de graphe, et inversement.

Plus bas niveau, afin d'améliorer la complexité générale du programme, des tables de hachage sont utilisées. A cet effet, la bibliothèque C standard ne contenant pas de telle structure de données, l'implémentation utilisée se base sur une bibliothque C tierce publiée sous licence GPL\footnote{Le code source est consultable à cette adresse: \texttt{https://github.com/ankurs/Hash-Table/}}.

\subsection{Etat actuel de l'avancement}
\label{implementation_controleur}

Actuellement, les différentes parties du contrôleur ont été implémentées de manière séparée:
\begin{itemize}
 \item L'invite de commande est opérationnelle: reconnaissance des différentes commandes possibles à l'aide d'expressions régulières et échappements des caractères;
 \item La gestion des graphes est mise en place: création à partir d'un fichier \textit{dot}, ajout/retrait/modification d'arête ou de n\oe ud, sauvegarde dans un fichier;
 \item Une bibliothèque de gestion de sockets utilisant les fonctions de \textit{sys/socket.h} est prête à l'utilisation. Elle permet la connexion, la déconnexion, l'envoi de messages, \dots Son implémentation est générique et permet une programmation évènementielle via des pointeurs de fonction correspondants aux actions à effectuer lors d'une connexion, de la récéption d'un message, etc.
\end{itemize}
Il ne reste donc qu'à \textit{lier} les différentes composantes entre elles pour obtenir un contrôleur respectant les attentes.


\section{Les routeurs}

\subsection{Leur rôle}

Les routeurs du projet simulent les routeurs d'un réseau réels. La principale différence est la connexion permanente qu'ils doivent maintenir avec le contrôleur. Leurs connaissances sur leur partie du réseau sont régulièrement actualisées par un appel de mise à jour au contrôleur. Parallèlement, ils sont connectés à leurs voisins et maintiennent une table de routage interne.

\subsection{Structure}

De même que le contrôleur, le programme du routeur se décompose en plusieurs parties distinctes:
\begin{itemize}
\item une invite de commande pour afficher le résultat des échanges avec le contrôleur et les autres routeurs, ainsi que pour communiquer avec l'utilisateur;
\item la gestion de leur table de routage;
\item un moyen de communiquer via le réseau avec le contrôleur et les routeurs voisins.
\end{itemize}

Pour des raisons d'optimisation en complexité, la table de routage est implémentée à l'aide de la classe \texttt{map} de la bibliothèque C++ standard.

\subsection{Etat actuel de l'avancement}

L'avancement du programme du routeur est semblable à celui du contrôleur: les différents modules évoqués dans la partie précédente sont opérationnels mais ne sont pas encore connectés entre eux; à l'exception des algorithmes de maintenance de la table de routage qui n'ont pas encore été écrits. Il ne reste donc plus qu'à effectuer cette liaison pour arriver à un routeur respectant les règles attendues.

Sauf retard, il est également prévu de consacrer une séance à la réalisation de tests de recette.

\subsection{Routeur $\leftrightarrow$ Routeur}

Après avoir reçu sa liste de voisins par le contrôleur, un routeur qui vient de rejoindre le réseau doit tout d'abord se signaler auprès de l'ensemble de ses voisins et établit avec eux une connexion permanente. De façon régulière, il doit échanger avec ses voisins ses vecteurs distances, et reçoit également les vecteurs distances de ces derniers. Ces nouvelles données lui permettent de mettre à jour sa table de routage si besoin est.

Un routeur doit également communiquer avec un voisin lorsqu'il doit transmettre un paquet en passant par ce voisin. Pour savoir à quel voisin transmettre le paquet, il lui suffit de regarder le destinataire du message et sa table de routage, et de le transmettre au bon routeur.

Quel que soit le type d'échange, le récepteur envoie systématiquement un message d'aquittement au routeur émetteur.

\begin{figure}[H]
\begin{center}
\begin{tikzpicture} 
\begin{umlseqdiag}
\umlobject[class=Router]{r$_1$} 
\umlobject[class=Router]{r$_2$}
\begin{umlcall}[op={connection}]{r$_1$}{r$_2$}
\begin{umlcall}[type=return]{r$_2$}{r$_1$}\end{umlcall}
\begin{umlcall}[op={send\_vectors}]{r$_1$}{r$_2$}\end{umlcall}
\begin{umlcall}[type=return]{r$_2$}{r$_1$}\end{umlcall}
\begin{umlcall}[op={update\_table}]{r$_2$}{r$_2$}\end{umlcall}

\begin{umlcall}[op={send\_message}]{r$_2$}{r$_1$}\end{umlcall}
\begin{umlcall}[type=return]{r$_1$}{r$_2$}\end{umlcall}
\end{umlcall} 
\end{umlseqdiag} 
\end{tikzpicture}
\caption{Diagramme de séquence des communications entre deux routeurs}
\end{center}
\end{figure}

\section{Nos objectifs pour la suite du projet}

Le déroulement prévisionnel du projet est indiqué sur le diagramme de Gantt donné en figure \ref{gantt}.

\vspace{20pt}

\begin{figure}[angle=45,height=.75,H]
 \centering
\begin{gantt}{10}{9}
  \begin{ganttitle}
    \numtitle{1}{1}{9}{1}
  \end{ganttitle}
  \ganttbar{Définition de l'architecture générale}{0}{1}
  \ganttbar{Mise en place des sockets}{1}{3}
  \ganttbar{Gestion des graphes}{1}{2}
  \ganttbar{Prompt}{1}{2}
  \ganttbar{Messages}{2}{1}
  \ganttbar{Tests}{4}{1}
  \ganttbar{Contrôleur}{5}{2}
  \ganttbar{Routeur}{6}{2}
  \ganttbar{Tests}{8}{1}
  
  
%   \ganttcon{1}{1}{1}{2}
%   \ganttcon{1}{1}{1}{3}
%   \ganttcon{1}{1}{1}{4}
%   \ganttcon{1}{1}{2}{5}
%   \ganttcon{3}{4}{4}{6}
%   \ganttcon{3}{5}{4}{6}
%   \ganttcon{4}{2}{4}{6}
%   \ganttcon{7}{7}{8}{9}
%   \ganttcon{8}{8}{8}{9}

  % \ganttbarcon{another consecutive task}{8}{2}
  % \ganttmilestone[color=cyan]{Milestone with color!}{4}
  % \ganttbar{another task}{2}{2}
  % \ganttbar[color=cyan]{another coloured task}{4}{4}
  % \ganttbar{another task}{4}{2}
  % \ganttcon{4}{5}{4}{7}
  % \ganttmilestonecon{A connected Milestone}{7}
  % \ganttbarcon{another consecutive task}{8}{2}
\end{gantt}
\caption{Diagramme de Gantt pour le projet}
\label{gantt}
\end{figure}


\end{document}
